home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / utils / UIDUtil.as < prev    next >
Encoding:
Text File  |  2009-02-12  |  8.3 KB  |  279 lines
  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    import flash.utils.Dictionary;
  5.    import mx.core.IPropertyChangeNotifier;
  6.    import mx.core.IUIComponent;
  7.    import mx.core.IUID;
  8.    import mx.core.mx_internal;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class UIDUtil
  13.    {
  14.       mx_internal static const VERSION:String = "3.0.0.0";
  15.       
  16.       private static const ALPHA_CHAR_CODES:Array = [48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70];
  17.       
  18.       private static var uidDictionary:Dictionary = new Dictionary(true);
  19.       
  20.       public function UIDUtil()
  21.       {
  22.          super();
  23.       }
  24.       
  25.       public static function fromByteArray(param1:ByteArray) : String
  26.       {
  27.          var _loc2_:Array = null;
  28.          var _loc3_:uint = 0;
  29.          var _loc4_:uint = 0;
  30.          var _loc5_:int = 0;
  31.          if(param1 != null && param1.length >= 16 && param1.bytesAvailable >= 16)
  32.          {
  33.             _loc2_ = new Array(36);
  34.             _loc3_ = 0;
  35.             _loc4_ = 0;
  36.             while(_loc4_ < 16)
  37.             {
  38.                if(_loc4_ == 4 || _loc4_ == 6 || _loc4_ == 8 || _loc4_ == 10)
  39.                {
  40.                   var _loc6_:*;
  41.                   _loc2_[_loc6_ = _loc3_++] = 45;
  42.                }
  43.                _loc5_ = param1.readByte();
  44.                _loc2_[_loc6_ = _loc3_++] = ALPHA_CHAR_CODES[(_loc5_ & 0xF0) >>> 4];
  45.                var _loc7_:*;
  46.                _loc2_[_loc7_ = _loc3_++] = ALPHA_CHAR_CODES[_loc5_ & 0x0F];
  47.                _loc4_++;
  48.             }
  49.             return String.fromCharCode.apply(null,_loc2_);
  50.          }
  51.          return null;
  52.       }
  53.       
  54.       public static function isUID(param1:String) : Boolean
  55.       {
  56.          var _loc2_:uint = 0;
  57.          var _loc3_:Number = NaN;
  58.          if(param1 != null && param1.length == 36)
  59.          {
  60.             _loc2_ = 0;
  61.             while(_loc2_ < 36)
  62.             {
  63.                _loc3_ = Number(param1.charCodeAt(_loc2_));
  64.                if(_loc2_ == 8 || _loc2_ == 13 || _loc2_ == 18 || _loc2_ == 23)
  65.                {
  66.                   if(_loc3_ != 45)
  67.                   {
  68.                      return false;
  69.                   }
  70.                }
  71.                else if(_loc3_ < 48 || _loc3_ > 70 || _loc3_ > 57 && _loc3_ < 65)
  72.                {
  73.                   return false;
  74.                }
  75.                _loc2_++;
  76.             }
  77.             return true;
  78.          }
  79.          return false;
  80.       }
  81.       
  82.       public static function createUID() : String
  83.       {
  84.          var _loc3_:int = 0;
  85.          var _loc4_:int = 0;
  86.          var _loc1_:Array = new Array(36);
  87.          var _loc2_:int = 0;
  88.          _loc3_ = 0;
  89.          while(_loc3_ < 8)
  90.          {
  91.             var _loc7_:*;
  92.             _loc1_[_loc7_ = _loc2_++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
  93.             _loc3_++;
  94.          }
  95.          _loc3_ = 0;
  96.          while(_loc3_ < 3)
  97.          {
  98.             _loc1_[_loc7_ = _loc2_++] = 45;
  99.             _loc4_ = 0;
  100.             while(_loc4_ < 4)
  101.             {
  102.                var _loc8_:*;
  103.                _loc1_[_loc8_ = _loc2_++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
  104.                _loc4_++;
  105.             }
  106.             _loc3_++;
  107.          }
  108.          _loc1_[_loc7_ = _loc2_++] = 45;
  109.          var _loc5_:Number = Number(new Date().getTime());
  110.          var _loc6_:String = ("0000000" + _loc5_.toString(16).toUpperCase()).substr(-8);
  111.          _loc3_ = 0;
  112.          while(_loc3_ < 8)
  113.          {
  114.             _loc1_[_loc8_ = _loc2_++] = _loc6_.charCodeAt(_loc3_);
  115.             _loc3_++;
  116.          }
  117.          _loc3_ = 0;
  118.          while(_loc3_ < 4)
  119.          {
  120.             _loc1_[_loc8_ = _loc2_++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
  121.             _loc3_++;
  122.          }
  123.          return String.fromCharCode.apply(null,_loc1_);
  124.       }
  125.       
  126.       public static function toByteArray(param1:String) : ByteArray
  127.       {
  128.          var _loc2_:ByteArray = null;
  129.          var _loc3_:uint = 0;
  130.          var _loc4_:String = null;
  131.          var _loc5_:uint = 0;
  132.          var _loc6_:uint = 0;
  133.          if(isUID(param1))
  134.          {
  135.             _loc2_ = new ByteArray();
  136.             _loc3_ = 0;
  137.             while(_loc3_ < param1.length)
  138.             {
  139.                _loc4_ = param1.charAt(_loc3_);
  140.                if(_loc4_ != "-")
  141.                {
  142.                   _loc5_ = getDigit(_loc4_);
  143.                   _loc3_++;
  144.                   _loc6_ = getDigit(param1.charAt(_loc3_));
  145.                   _loc2_.writeByte((_loc5_ << 4 | _loc6_) & 0xFF);
  146.                }
  147.                _loc3_++;
  148.             }
  149.             _loc2_.position = 0;
  150.             return _loc2_;
  151.          }
  152.          return null;
  153.       }
  154.       
  155.       private static function getDigit(param1:String) : uint
  156.       {
  157.          switch(param1)
  158.          {
  159.             case "A":
  160.             case "a":
  161.                return 10;
  162.             case "B":
  163.             case "b":
  164.                return 11;
  165.             case "C":
  166.             case "c":
  167.                return 12;
  168.             case "D":
  169.             case "d":
  170.                return 13;
  171.             case "E":
  172.             case "e":
  173.                return 14;
  174.             case "F":
  175.             case "f":
  176.                return 15;
  177.             default:
  178.                return new uint(param1);
  179.          }
  180.       }
  181.       
  182.       public static function getUID(param1:Object) : String
  183.       {
  184.          var result:String = null;
  185.          var xitem:XML = null;
  186.          var nodeKind:String = null;
  187.          var notificationFunction:Function = null;
  188.          var item:Object = param1;
  189.          result = null;
  190.          if(item == null)
  191.          {
  192.             return result;
  193.          }
  194.          if(item is IUID)
  195.          {
  196.             result = IUID(item).uid;
  197.             if(result == null || result.length == 0)
  198.             {
  199.                result = createUID();
  200.                IUID(item).uid = result;
  201.             }
  202.          }
  203.          else if(item is IPropertyChangeNotifier && !(item is IUIComponent))
  204.          {
  205.             result = IPropertyChangeNotifier(item).uid;
  206.             if(result == null || result.length == 0)
  207.             {
  208.                result = createUID();
  209.                IPropertyChangeNotifier(item).uid = result;
  210.             }
  211.          }
  212.          else
  213.          {
  214.             if(item is String)
  215.             {
  216.                return item as String;
  217.             }
  218.             try
  219.             {
  220.                if(item is XMLList && item.length == 1)
  221.                {
  222.                   item = item[0];
  223.                }
  224.                if(item is XML)
  225.                {
  226.                   xitem = XML(item);
  227.                   nodeKind = xitem.nodeKind();
  228.                   if(nodeKind == "text" || nodeKind == "attribute")
  229.                   {
  230.                      return xitem.toString();
  231.                   }
  232.                   notificationFunction = xitem.notification();
  233.                   if(!(notificationFunction is Function))
  234.                   {
  235.                      notificationFunction = XMLNotifier.mx_internal::initializeXMLForNotification();
  236.                      xitem.setNotification(notificationFunction);
  237.                   }
  238.                   if(notificationFunction["uid"] == undefined)
  239.                   {
  240.                      result = notificationFunction["uid"] = createUID();
  241.                   }
  242.                   result = notificationFunction["uid"];
  243.                }
  244.                else
  245.                {
  246.                   if("mx_internal_uid" in item)
  247.                   {
  248.                      return item.mx_internal_uid;
  249.                   }
  250.                   if("uid" in item)
  251.                   {
  252.                      return item.uid;
  253.                   }
  254.                   result = uidDictionary[item];
  255.                   if(!result)
  256.                   {
  257.                      result = createUID();
  258.                      try
  259.                      {
  260.                         item.mx_internal_uid = result;
  261.                      }
  262.                      catch(e:Error)
  263.                      {
  264.                         uidDictionary[item] = result;
  265.                      }
  266.                   }
  267.                }
  268.             }
  269.             catch(e:Error)
  270.             {
  271.                result = item.toString();
  272.             }
  273.          }
  274.          return result;
  275.       }
  276.    }
  277. }
  278.  
  279.